/**
 * @description Rsd.cqrs.List服务介于数据通讯层和UI交互层中间
 * @description 使用schema内嵌服务，处理 单表 的数据对象查询操作，列表查询和对象删除操作,不负责处理页面状态及页面交互
 */
Rsd.define('Rsd.cqrs.List', {
    extend: 'Rsd.common.Object',
    requires: ['Rsd.data.Service'],
    xtype: 'cqrs-list', 
    /**
     * 该对象所属页面
     */
    owner: null,
    /**
    * */
    constructor: function CQRSList(config) {
        config = config || {};
        this.apply(config);

    },
    /**
     * @description 获取Schema，并初始化控件  
     * @param {*} callback 
     * @returns 
     */
    getSchema: function getSchema(callback) {
        var me = this;
        if (me.modelSchema) {
            if (callback) { 
                callback(modelSchema);
            }
            return;
        }
         //
        if(me.owner.modelSchema)
        {
            me.modelSchema = me.owner.modelSchema;
            if (callback) {
                callback( me.modelSchema );
            }
            return ;
        }
        //
        if(me.owner.modelType)
        {
            Rsd.app.getSchema(me.owner.modelType, function (modelSchema) {

                if (modelSchema) {
                    me.modelSchema = modelSchema; 
                }
                else {
                    me.getSchemaFailed = true;
                    console.error('未找到类型：' + me.owner.modelType + '的Schema对象');
                }

                if (callback) {
                    callback(modelSchema);
                }
            });
            return;
        }
       
        //不存在
        if (callback) {
            callback(null);
        }
        
    },

    /**
     * @description 【数据流方向-向下】从接口查询数据，并加载到控件 
     * @param {*} grid 
     */
    list: function list(args,callback) {
        var me = this;
        if(!me.modelSchema && !me.getSchemaFailed)
        {
            //console.error('类型配置错误',me);
            //Rsd.alert('类型配置错误:' + (me.owner.modelType || '') );
            me.getSchema(function(){
                me.list(args,callback);
            });
            return;
        }
        var _view = me.owner;
       
        if(Rsd.isObject(args))
        {
            Rsd.showWaiting(_view.id, _view); 
            me.modelSchema.listObjects(args,function(resp){
 
                if (resp===undefined || resp === null) {
                    Rsd.alert('数据加载失败', '未获取到数据（网络故障）。');
                    return false;
                }
                    
                if (!resp.success && Rsd.isEmpty(resp.msg)) 
                {
                    console.error('未知错误(UI0009),请查看日志。',resp);
                    return false;
                } 

                if (resp.success) {
                    var _data = resp.data || {};
                     
                    if (Rsd.isArray(_data)) {
                        _view.setPagingOpt({ pageSize: opt.pageSize, pageIndex: 0, pageCount: 1, totalCount: _data.length });
                    }
                    else 
                    {
                        var listName =_view.listMember || _view.menu.listMember || 'rows';
                        _view.callParentFn("load", [_data[listName],callback]);
                        _view.setPagingOpt({ pageSize: _data.pagesize || 100, pageIndex: _data.pageindex || 0, pageCount: _data.pagecount || 0, totalCount: _data.total || 0 });
                    } 
                }
 
                Rsd.closeWaiting(_view.id);

            });
        }
        else
        {
            _view.callParentFn("load", [data||this.data,callback]);
        }
         
    },
    /**
     * @description 【数据流方向-向上】提交接口删除对象，并从控件中删除对象 
     * @param {*} grid 
     */
    "delete": function _delete(row, callback) {
        var me = this; 
        var _row = row; 
        if (Rsd.isEmpty(me.owner.modelType)) {
            Rsd.alert("删除失败\r\页面modelType属性为空。");
            return;
        }

        if (Rsd.isEmpty(me.modelSchema)) {
            Rsd.alert("删除失败\r\nSchema属性为空。");
            return;
        }

        if (me.modelSchema instanceof Rsd.data.ModelSchema) {
        }
        else {
            console.log(me.modelSchema);
            Rsd.alert("删除失败\r\nSchema错误(不是有效的Rsd.data.ModelSchema对象)。");
            return;
        }

        if (Rsd.isEmpty(me.modelSchema.keys)) {
            Rsd.msg("主键不存在，无法执行删除。");
            return;
        }
        //根据主键值是否存在 判断是否已保存
        if (!Rsd.isEmpty(_row[me.modelSchema.keys[0]])) {
            //请求删除
            me.modelSchema.deleteObject(_row, function (resp) {
                if (resp.success)
                {
                    Rsd.popup('数据已删除');
                    if (callback) {
                        callback(resp);
                    }
                    return false;
                  
                }else
                {
                    Rsd.alert('数据删除失败', resp.msg);
                }
                
                return true;
            });

            return;
        }
        //尚未保存，不需要请求远端
        if(callback)
        {
            callback();
        }
        return;
    }
});